package frankenstein.datastructures;
import java.util.*;
public class Weights extends ParentModel {

	private double positiveModifiabilityWeight;
	private double negativeModifiabilityWeight;
	private double positiveEfficiencyWeight;
	private double negativeEfficiencyWeight;
	private double complexityWeight;
	private double scenarioWeight;
	
	private Vector<Double> allWeights;

	
	               
	public double getPositiveEfficiencyWeight() {
		return positiveEfficiencyWeight;
	}

	public void setPositiveEfficiencyWeight(double positiveEfficiencyWeight) {
		this.positiveEfficiencyWeight = positiveEfficiencyWeight;
	}

	public double getNegativeEfficiencyWeight() {
		return negativeEfficiencyWeight;
	}

	public void setNegativeEfficiencyWeight(double negativeEfficiencyWeight) {
		this.negativeEfficiencyWeight = negativeEfficiencyWeight;
	}

	public double getPositiveModifiabilityWeight() {
		return positiveModifiabilityWeight;
	}

	public void setPositiveModifiabilityWeight(double positiveModifiabilityWeight) {
		this.positiveModifiabilityWeight = positiveModifiabilityWeight;
	}

	public double getNegativeModifiabilityWeight() {
		return negativeModifiabilityWeight;
	}

	public void setNegativeModifiabilityWeight(double negativeModifiabilityWeight) {
		this.negativeModifiabilityWeight = negativeModifiabilityWeight;
	}

	public double getComplexityWeight() {
		return complexityWeight;
	}

	public void setComplexityWeight(double complexityWeight) {
		this.complexityWeight = complexityWeight;
	}

	public double getScenarioWeight() {
		return scenarioWeight;
	}

	public void setScenarioWeight(double scenarioWeight) {
		this.scenarioWeight = scenarioWeight;
	}

	public Vector<Double> getAllWeights() {
		return allWeights;
	}

	public void setAllWeights(Vector<Double> allWeights) {
		this.allWeights = allWeights;
	}
	
	public Weights(Vector<Double> weights){
		setAllWeights(weights);
	this.positiveModifiabilityWeight = weights.get(0);
	this.negativeModifiabilityWeight = weights.get(1);
	this.positiveEfficiencyWeight = weights.get(2);
	this.negativeEfficiencyWeight = weights.get(3);
	this.complexityWeight = weights.get(4);
	this.scenarioWeight = weights.get(5);
	
	}
	
	public Weights(){
		
		allWeights = new Vector<Double>();		
		getParametersData();
	}
	
	public void getParametersData(){
		
	}
	public void setParameters(Vector<Double> weights){
		setAllWeights(weights);
	}

	public Weights createClone() {

		Weights clone = new Weights();
		for(Double weight:allWeights){
			clone.getAllWeights().add(new Double(weight.doubleValue()));
		}
		clone.setComplexityWeight(complexityWeight);
		clone.setNegativeEfficiencyWeight(negativeEfficiencyWeight);
		clone.setNegativeModifiabilityWeight(negativeModifiabilityWeight);
		//clone.setParameters(weights)
		clone.setPositiveEfficiencyWeight(positiveEfficiencyWeight);
		clone.setPositiveModifiabilityWeight(positiveModifiabilityWeight);
		clone.setScenarioWeight(scenarioWeight);
		return clone;
	}
}
